{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clear previously loaded data.\n",
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "try:\n",
    "   del X_train, y_train\n",
    "   del X_test, y_test\n",
    "   print('Clear previously loaded data.')\n",
    "except:\n",
    "   pass\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.280324\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 1:\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "**Your answer:** *Fill this in*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: -0.591386 analytic: -0.591386, relative error: 1.268578e-07\n",
      "numerical: -0.043453 analytic: -0.043453, relative error: 1.310401e-06\n",
      "numerical: -2.132695 analytic: -2.132696, relative error: 3.445366e-08\n",
      "numerical: -1.014076 analytic: -1.014076, relative error: 5.169928e-08\n",
      "numerical: -1.115428 analytic: -1.115428, relative error: 4.485478e-08\n",
      "numerical: 0.561070 analytic: 0.561070, relative error: 2.223331e-08\n",
      "numerical: -1.137678 analytic: -1.137678, relative error: 2.600677e-08\n",
      "numerical: -1.503806 analytic: -1.503806, relative error: 2.427715e-08\n",
      "numerical: 1.440679 analytic: 1.440679, relative error: 2.908106e-08\n",
      "numerical: 0.481803 analytic: 0.481803, relative error: 6.202431e-08\n",
      "numerical: -0.915505 analytic: -0.915505, relative error: 3.139133e-08\n",
      "numerical: -2.301354 analytic: -2.301354, relative error: 7.213229e-10\n",
      "numerical: 0.148893 analytic: 0.148893, relative error: 1.041832e-07\n",
      "numerical: 0.403750 analytic: 0.403750, relative error: 4.451074e-08\n",
      "numerical: 0.303149 analytic: 0.303149, relative error: 2.033502e-07\n",
      "numerical: 1.540301 analytic: 1.540301, relative error: 4.101389e-08\n",
      "numerical: -2.168784 analytic: -2.168784, relative error: 1.644469e-08\n",
      "numerical: -2.939279 analytic: -2.939279, relative error: 3.675135e-09\n",
      "numerical: 1.822934 analytic: 1.822934, relative error: 3.167241e-08\n",
      "numerical: -1.502339 analytic: -1.502339, relative error: 2.655268e-09\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.280324e+00 computed in 0.007353s\n",
      "vectorized loss: 1.177309e+03 computed in 0.012578s\n",
      "Loss difference: 1175.028789\n",
      "Gradient difference: 505.149525\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 1.000000e-07 reg 7.000000e+03 train accuracy: 0.134265 val accuracy: 0.137000\n",
      "lr 1.000000e-07 reg 8.000000e+03 train accuracy: 0.110878 val accuracy: 0.112000\n",
      "lr 1.000000e-07 reg 9.000000e+03 train accuracy: 0.105102 val accuracy: 0.107000\n",
      "lr 1.000000e-07 reg 1.000000e+04 train accuracy: 0.106469 val accuracy: 0.109000\n",
      "lr 1.000000e-07 reg 1.100000e+04 train accuracy: 0.094347 val accuracy: 0.107000\n",
      "lr 1.000000e-07 reg 1.200000e+04 train accuracy: 0.085673 val accuracy: 0.077000\n",
      "lr 1.000000e-07 reg 1.300000e+04 train accuracy: 0.073224 val accuracy: 0.078000\n",
      "lr 1.000000e-07 reg 4.700000e+04 train accuracy: 0.070408 val accuracy: 0.071000\n",
      "lr 1.000000e-07 reg 4.800000e+04 train accuracy: 0.074796 val accuracy: 0.078000\n",
      "lr 1.000000e-07 reg 4.900000e+04 train accuracy: 0.099898 val accuracy: 0.102000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.117143 val accuracy: 0.120000\n",
      "lr 1.000000e-07 reg 5.100000e+04 train accuracy: 0.097000 val accuracy: 0.095000\n",
      "lr 1.000000e-07 reg 5.200000e+04 train accuracy: 0.102388 val accuracy: 0.104000\n",
      "lr 1.000000e-07 reg 5.300000e+04 train accuracy: 0.089837 val accuracy: 0.093000\n",
      "lr 5.000000e-07 reg 7.000000e+03 train accuracy: 0.120878 val accuracy: 0.108000\n",
      "lr 5.000000e-07 reg 8.000000e+03 train accuracy: 0.103327 val accuracy: 0.109000\n",
      "lr 5.000000e-07 reg 9.000000e+03 train accuracy: 0.103449 val accuracy: 0.089000\n",
      "lr 5.000000e-07 reg 1.000000e+04 train accuracy: 0.093388 val accuracy: 0.095000\n",
      "lr 5.000000e-07 reg 1.100000e+04 train accuracy: 0.098571 val accuracy: 0.109000\n",
      "lr 5.000000e-07 reg 1.200000e+04 train accuracy: 0.107837 val accuracy: 0.116000\n",
      "lr 5.000000e-07 reg 1.300000e+04 train accuracy: 0.078571 val accuracy: 0.060000\n",
      "lr 5.000000e-07 reg 4.700000e+04 train accuracy: 0.102939 val accuracy: 0.108000\n",
      "lr 5.000000e-07 reg 4.800000e+04 train accuracy: 0.088755 val accuracy: 0.090000\n",
      "lr 5.000000e-07 reg 4.900000e+04 train accuracy: 0.095653 val accuracy: 0.097000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.087673 val accuracy: 0.095000\n",
      "lr 5.000000e-07 reg 5.100000e+04 train accuracy: 0.098061 val accuracy: 0.096000\n",
      "lr 5.000000e-07 reg 5.200000e+04 train accuracy: 0.087388 val accuracy: 0.090000\n",
      "lr 5.000000e-07 reg 5.300000e+04 train accuracy: 0.095776 val accuracy: 0.099000\n",
      "best validation accuracy achieved during cross-validation: 0.137000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "#regularization_strengths = [2.5e4, 5e4]\n",
    "regularization_strengths =[(1+0.1*i)*1e4 for i in range(-3,4)] + [(5+0.1*i)*1e4 for i in range(-3,4)]\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "for lr in learning_rates:\n",
    "    for rs in regularization_strengths:\n",
    "        softmax = Softmax()\n",
    "        softmax.train(X_train, y_train, lr, rs, num_iters=2000)\n",
    "        y_train_pred = softmax.predict(X_train)\n",
    "        train_accuracy = np.mean(y_train == y_train_pred)\n",
    "        y_val_pred = softmax.predict(X_val)\n",
    "        val_accuracy = np.mean(y_val == y_val_pred)\n",
    "        if val_accuracy > best_val:\n",
    "            best_val = val_accuracy\n",
    "            best_softmax = softmax           \n",
    "        results[(lr,rs)] = train_accuracy, val_accuracy\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.128000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Inline Question** - *True or False*\n",
    "\n",
    "It's possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "*Your answer*:\n",
    "\n",
    "*Your explanation*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
